    // Copyright (C) 2006  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_SOCKETS_EXTENSIONs_CPP
    #define DLIB_SOCKETS_EXTENSIONs_CPP

    #include <string>
    #include <sstream>
    #include "../sockets.h"
    #include "../error.h"
    #include "sockets_extensions.h"
    #include "../timer.h"
    #include "../algs.h"
    #include "../timeout.h"
    #include "../misc_api.h"
    #include "../serialize.h"
    #include "../string.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        network_address::
        network_address(
            const std::string& full_address
        )
        {
            std::istringstream sin(full_address);
            sin >> *this;
            if (!sin || sin.peek() != EOF)
                throw invalid_network_address("invalid network address: " + full_address);
        }

    // ----------------------------------------------------------------------------------------

        void serialize(
            const network_address& item,
            std::ostream& out
        )
        {
            serialize(item.host_address, out);
            serialize(item.port, out);
        }

    // ----------------------------------------------------------------------------------------

        void deserialize(
            network_address& item,
            std::istream& in
        )
        {
            deserialize(item.host_address, in);
            deserialize(item.port, in);
        }

    // ----------------------------------------------------------------------------------------

        std::ostream& operator<< (
            std::ostream& out,
            const network_address& item
        )
        {
            out << item.host_address << ":" << item.port;
            return out;
        }

    // ----------------------------------------------------------------------------------------

        std::istream& operator>> (
            std::istream& in,
            network_address& item
        )
        {
            std::string temp;
            in >> temp;

            std::string::size_type pos = temp.find_last_of(":");
            if (pos == std::string::npos)
            {
                in.setstate(std::ios::badbit);
                return in;
            }

            item.host_address = temp.substr(0, pos);
            try
            {
                item.port = sa = temp.substr(pos+1);
            } catch (std::exception& )
            {
                in.setstate(std::ios::badbit);
                return in;
            }

            return in;
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        connection* connect (
            const std::string& host_or_ip,
            unsigned short port
        )
        {
            std::string ip;
            connection* con;
            if (is_ip_address(host_or_ip))
            {
                ip = host_or_ip;
            }
            else
            {
                if( hostname_to_ip(host_or_ip,ip))
                    throw socket_error(ERESOLVE,"unable to resolve '" + host_or_ip + "' in connect()");
            }

            if(create_connection(con,port,ip))
            {
                std::ostringstream sout;
                sout << "unable to connect to '" << host_or_ip << ":" << port << "'";
                throw socket_error(sout.str());
            }

            return con;
        }

    // ----------------------------------------------------------------------------------------

        connection* connect (
            const network_address& addr
        )
        {
            return connect(addr.host_address, addr.port);
        }

    // ----------------------------------------------------------------------------------------

        namespace connect_timeout_helpers
        {
            mutex connect_mutex;
            signaler connect_signaler(connect_mutex);
            timestamper ts;
            long outstanding_connects = 0;

            struct thread_data
            {
                std::string host_or_ip;
                unsigned short port;
                connection* con;
                bool connect_ended;
                bool error_occurred;
            };

            void thread(void* param)
            {
                thread_data p = *static_cast<thread_data*>(param);
                try
                {
                    p.con = connect(p.host_or_ip, p.port);
                }
                catch (...)
                {
                    p.error_occurred = true;
                }

                auto_mutex M(connect_mutex);
                // report the results back to the connect() call that spawned this
                // thread.
                static_cast<thread_data*>(param)->con = p.con;
                static_cast<thread_data*>(param)->error_occurred = p.error_occurred;
                connect_signaler.broadcast();

                // wait for the call to connect() that spawned this thread to terminate
                // before we delete the thread_data struct.
                while (static_cast<thread_data*>(param)->connect_ended == false)
                    connect_signaler.wait();

                connect_signaler.broadcast();
                --outstanding_connects;
                delete static_cast<thread_data*>(param);
            }
        }

        connection* connect (
            const std::string& host_or_ip,
            unsigned short port,
            unsigned long timeout
        )
        {
            using namespace connect_timeout_helpers;

            auto_mutex M(connect_mutex);

            const uint64 end_time = ts.get_timestamp() + timeout*1000;

            // wait until there are less than 100 outstanding connections
            while (outstanding_connects > 100)
            {
                uint64 cur_time = ts.get_timestamp();
                if (end_time > cur_time)
                {
                    timeout = static_cast<unsigned long>((end_time - cur_time)/1000);
                }
                else
                {
                    throw socket_error("unable to connect to '" + host_or_ip + "' because connect timed out");
                }

                connect_signaler.wait_or_timeout(timeout);
            }

            thread_data* data = new thread_data;
            data->host_or_ip = host_or_ip.c_str();
            data->port = port;
            data->con = 0;
            data->connect_ended = false;
            data->error_occurred = false;

            if (create_new_thread(thread, data) == false)
            {
                delete data;
                throw socket_error("unable to connect to '" + host_or_ip);
            }

            ++outstanding_connects;

            // wait until we have a connection object
            while (data->con == 0)
            {
                uint64 cur_time = ts.get_timestamp();
                if (end_time > cur_time && data->error_occurred == false)
                {
                    timeout = static_cast<unsigned long>((end_time - cur_time)/1000);
                }
                else
                {
                    // let the thread know that it should terminate
                    data->connect_ended = true;
                    connect_signaler.broadcast();
                    if (data->error_occurred)
                        throw socket_error("unable to connect to '" + host_or_ip);
                    else
                        throw socket_error("unable to connect to '" + host_or_ip + "' because connect timed out");
                }

                connect_signaler.wait_or_timeout(timeout);
            }

            // let the thread know that it should terminate
            data->connect_ended = true;
            connect_signaler.broadcast();
            return data->con;
        }

    // ----------------------------------------------------------------------------------------

        bool is_ip_address (
            std::string ip
        )
        {
            for (std::string::size_type i = 0; i < ip.size(); ++i)
            {
                if (ip[i] == '.')
                    ip[i] = ' ';
            }
            std::istringstream sin(ip);

            bool bad = false;
            int num;
            for (int i = 0; i < 4; ++i)
            {
                sin >> num;
                if (!sin || num < 0 || num > 255)
                {
                    bad = true;
                    break;
                }
            }

            if (sin.get() != EOF)
                bad = true;

            return !bad;
        }

    // ----------------------------------------------------------------------------------------

        void close_gracefully (
            connection* con,
            unsigned long timeout
        )
        {
            std::unique_ptr<connection> ptr(con);
            close_gracefully(ptr,timeout);
        }

    // ----------------------------------------------------------------------------------------

        void close_gracefully (
            std::unique_ptr<connection>& con,
            unsigned long timeout
        )
        {
            if (!con)
                return;

            if(con->shutdown_outgoing())
            {
                // there was an error so just close it now and return
                con.reset();
                return;
            }

            try
            {
                dlib::timeout t(*con,&connection::shutdown,timeout);

                char junk[100];
                // wait for the other end to close their side
                while (con->read(junk,sizeof(junk)) > 0) ;
            }
            catch (...)
            {
                con.reset();
                throw;
            }

            con.reset();
        }

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_SOCKETS_EXTENSIONs_CPP